Estructura de datos en python

Autor: Carlos Prado
Fecha: 01/07/2019

Ejercicios resueltos:

  • 1.Ecuaciones de segundo grado.
  • 2.Frase palíndromo.
  • 3.Operaciones con diccionarios.
  • 4.Código Morse.
  • 5.Comparación de claves en diccionarios.
  • 6.Algoritmo Criba de Eratóstenes.
  • 7.Clase string función title().
  • 8.Función max(), M.C.D.
  • 9.Cifrado del César.
  • 10.Función sort().

1.Crea una función que reciba los tres coeficientes a, b y c para resolver una ecuación de segundo grado. Muestra la solución por pantalla y ayúdate de la librería Math para acceder a la función raíz cuadrada.

Ecuación de 2° grado: $ax^2+bx + c = 0$ donde $a\neq0$,
donde x es la variable, y a, b y c constantes; a es el coeficiente cuadrático (distinto de 0), b el coeficiente lineal y c es el término independiente.

In [14]:
import math
In [15]:
def ecuacion(a,b,c):
    if (a != 0):
        x1 = (-b + math.sqrt(b**2 - 4*a*c)) / (2 * a)
        x2 = (-b - math.sqrt(b**2 - 4*a*c)) / (2 * a)
    else:     
        return print("No cumple con la condicion a!=0")
    return x1,x2
In [17]:
ecuacion(1,-3,2)
Out[17]:
(2.0, 1.0)

2.Crea una función que lea una frase de teclado y nos diga si es o no un palíndromo (frase que se lee igual de izquierda a derecha o al revés como por ejemplo La ruta nos aportó otro paso natural.)

In [18]:
#Con esta función eliminamos las tildes en vocales mayúsculas y minúsculas.
def sacar_tilde(cadena):
    reemplazar = (("á", "a"),("é", "e"),("í", "i"),("ó", "o"),("ú", "u"))
    for a, b in reemplazar:
        cadena = cadena.replace(a, b).replace(a.upper(), b.upper())
    return cadena
In [ ]:
print(sacar_tilde("Ejémpló 1 : Lá rútá nós ápórtó ótró pásó nátúrál"))
print(sacar_tilde("EJEMPLO 2 : LÁ RÚTÁ NÓS ÁPÓRTÓ ÓTRÓ PÁSÓ NÁTÚRÁL"))
In [20]:
def palindromo():
    texto = input("Ingrese una palabra o frase: ")
    copia = texto.lower()
    s=sacar_tilde(copia)
    sin_espacios = s.replace(" ", "") 
    invertir = sin_espacios[::-1]
    print("Palabra invertida: ",texto[::-1])
    print("Longitud: ",len(texto)," letras")
    print("Eliminando espacios: ",sin_espacios)
    print("Reducción: ",len(sin_espacios)," letras")
    if (sin_espacios == invertir):
        print("CONCLUSION: la palabra ingresada SI es Palíndromo!!")
    else:
        print("CONCLUSION: La palabra ingresada NO es Palíndromo!!")    
In [21]:
#Funcion Principal
palindromo()
Ingrese una palabra o frase: Lá rútá nós ápórtó ótró pásó nátúrál
Palabra invertida:  lárútán ósáp órtó ótrópá són átúr áL
Longitud:  36  letras
Eliminando espacios:  larutanosaportootropasonatural
Reducción:  30  letras
CONCLUSION: la palabra ingresada SI es Palíndromo!!

3.Crea un diccionario que tenga por claves los números del 1 al 10 y como valores sus raíces cuadradas

In [22]:
#Creando un diccionario con clave y valor
diccionario = {
    1 : math.sqrt(1), 2 : math.sqrt(2),
    3 : math.sqrt(3), 4 : math.sqrt(4),
    5 : math.sqrt(5), 6 : math.sqrt(6),
    7 : math.sqrt(7), 8 : math.sqrt(8),
    9 : math.sqrt(9), 10 : math.sqrt(10),
}
In [23]:
# Recorrer un diccionario, imprimiendo su clave-valor
for clave,valor in diccionario.items():
    print (clave,valor)
1 1.0
2 1.4142135623730951
3 1.7320508075688772
4 2.0
5 2.23606797749979
6 2.449489742783178
7 2.6457513110645907
8 2.8284271247461903
9 3.0
10 3.1622776601683795
In [24]:
# Otra forma de visualizar los datos
keys = diccionario.keys()
items = diccionario.items()
values= diccionario.values()
In [25]:
items
Out[25]:
dict_items([(1, 1.0), (2, 1.4142135623730951), (3, 1.7320508075688772), (4, 2.0), (5, 2.23606797749979), (6, 2.449489742783178), (7, 2.6457513110645907), (8, 2.8284271247461903), (9, 3.0), (10, 3.1622776601683795)])
In [26]:
keys
Out[26]:
dict_keys([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
In [27]:
values
Out[27]:
dict_values([1.0, 1.4142135623730951, 1.7320508075688772, 2.0, 2.23606797749979, 2.449489742783178, 2.6457513110645907, 2.8284271247461903, 3.0, 3.1622776601683795])

4.Crea un diccionario que tenga como claves las letras del alfabeto castellano y como valores los símbolos del código morse (los tienes todos en la Wikipedia). A continuación crea un programa que lea una frase del teclado y te la convierta a Morse utilizando el diccionario anterior.

In [28]:
#Funcion para traducir
def traduccion(c):
    cont = 0
    #Creando un diccionario del abecedario español
    morse = {
        "A" : ".-", "B" : "-...",
        "C" : "-.-.", "CH" : "----",
        "D" : "-..", "E" : ".",
        "F" : "..-.", "G" : "--.",
        "H" : "....", "I" : "..", 
        "J" : ".---", "K" : "-.-", 
        "L" : ".-..", "M" : "--", 
        "N" : "-.", "Ñ" : "--.--", 
        "O" : "---", "P" : ".--.",
        "Q" : "--.-", "R" : ".-.",
        "S" : "...", "T" : "-",
        "U" : "..-", "V" : "...-",
        "W" : ".--", "X" : "-..-",
        "Y" : "-.--", "Z" : "--..",
} 
    for i in range(len(c)):
        letra=c[i]
        for clave,valor in morse.items():
            if (clave.lower() == letra):
                if (c[i]== "c" and c[i+1] == "h" ):
                    print(" --> reemplazar CH por -->",morse.get("CH"))
                print(" ",c[i]," --> Código -->",valor)
                #print("Mayuscula:",clave)
                #print("Codigo Morse:",valor)           
In [29]:
#Funcion Main
def traductor():
    texto = input("Ingrese una palabra o frase: ")
    copia = texto.lower()
    s=sacar_tilde(copia)
    sin_espacios = s.replace(" ", "")
    traduccion(sin_espacios)
    print("Eliminando espacios: ",sin_espacios)
    print("Reducción: ",len(sin_espacios)," letras")
    return    
In [30]:
traductor()
Ingrese una palabra o frase: La gran muralla china
  l  --> Código --> .-..
  a  --> Código --> .-
  g  --> Código --> --.
  r  --> Código --> .-.
  a  --> Código --> .-
  n  --> Código --> -.
  m  --> Código --> --
  u  --> Código --> ..-
  r  --> Código --> .-.
  a  --> Código --> .-
  l  --> Código --> .-..
  l  --> Código --> .-..
  a  --> Código --> .-
 --> reemplazar CH por --> ----
  c  --> Código --> -.-.
  h  --> Código --> ....
  i  --> Código --> ..
  n  --> Código --> -.
  a  --> Código --> .-
Eliminando espacios:  lagranmurallachina
Reducción:  18  letras

5.Crea una función que dados dos diccionarios nos diga que claves están presentes en ambos.

In [31]:
def playstation():
    consolas = {1 : "Nes", 2 : "Play 1", 3 : "Snes", 4 : "Play 2", 5 : "Megadrive", 6 : "Play 3", 7 : "Family", 8 : "Play 4"}
    lanzamiento = {2 : "3 de diciembre de 1994", 4 : "4 de marzo del año 2000", 6 : "11 de noviembre de 2006", 8 : "15 de noviembre de 2013"}
    for consolas in lanzamiento:
        print("Claves: ",consolas)
    return
    
               
In [32]:
playstation()
Claves:  2
Claves:  4
Claves:  6
Claves:  8

6.Crea una función que dado un número N nos diga si es primo o no (tiene que ir dividiendo por todos los números x comprendidos entre 2 y el propio número N menos uno y ver si el cociente de N/x tiene resto entero o no).
fuente: https://es.wikibooks.org/wiki/Implementaci%C3%B3n_de_algoritmos_de_teor%C3%ADa_de_n%C3%BAmeros/Criba_de_Erat%C3%B3stenes

In [2]:
#Algoritmo criba de eratostenes 
def criba_eratostenes(n):
    multiplos = set()
    for i in range(2, n-1):
        if (n%i==0):
            print("División: ",n,"/",i,"=",True)
        else:
            print("División: ",n,"/",i,"=",False)
        if i not in multiplos:
            print("N° Primo: ",i)
            multiplos.update(range(i*i, n+1, i))
In [3]:
criba_eratostenes(100)
División:  100 / 2 = True
N° Primo:  2
División:  100 / 3 = False
N° Primo:  3
División:  100 / 4 = True
División:  100 / 5 = True
N° Primo:  5
División:  100 / 6 = False
División:  100 / 7 = False
N° Primo:  7
División:  100 / 8 = False
División:  100 / 9 = False
División:  100 / 10 = True
División:  100 / 11 = False
N° Primo:  11
División:  100 / 12 = False
División:  100 / 13 = False
N° Primo:  13
División:  100 / 14 = False
División:  100 / 15 = False
División:  100 / 16 = False
División:  100 / 17 = False
N° Primo:  17
División:  100 / 18 = False
División:  100 / 19 = False
N° Primo:  19
División:  100 / 20 = True
División:  100 / 21 = False
División:  100 / 22 = False
División:  100 / 23 = False
N° Primo:  23
División:  100 / 24 = False
División:  100 / 25 = True
División:  100 / 26 = False
División:  100 / 27 = False
División:  100 / 28 = False
División:  100 / 29 = False
N° Primo:  29
División:  100 / 30 = False
División:  100 / 31 = False
N° Primo:  31
División:  100 / 32 = False
División:  100 / 33 = False
División:  100 / 34 = False
División:  100 / 35 = False
División:  100 / 36 = False
División:  100 / 37 = False
N° Primo:  37
División:  100 / 38 = False
División:  100 / 39 = False
División:  100 / 40 = False
División:  100 / 41 = False
N° Primo:  41
División:  100 / 42 = False
División:  100 / 43 = False
N° Primo:  43
División:  100 / 44 = False
División:  100 / 45 = False
División:  100 / 46 = False
División:  100 / 47 = False
N° Primo:  47
División:  100 / 48 = False
División:  100 / 49 = False
División:  100 / 50 = True
División:  100 / 51 = False
División:  100 / 52 = False
División:  100 / 53 = False
N° Primo:  53
División:  100 / 54 = False
División:  100 / 55 = False
División:  100 / 56 = False
División:  100 / 57 = False
División:  100 / 58 = False
División:  100 / 59 = False
N° Primo:  59
División:  100 / 60 = False
División:  100 / 61 = False
N° Primo:  61
División:  100 / 62 = False
División:  100 / 63 = False
División:  100 / 64 = False
División:  100 / 65 = False
División:  100 / 66 = False
División:  100 / 67 = False
N° Primo:  67
División:  100 / 68 = False
División:  100 / 69 = False
División:  100 / 70 = False
División:  100 / 71 = False
N° Primo:  71
División:  100 / 72 = False
División:  100 / 73 = False
N° Primo:  73
División:  100 / 74 = False
División:  100 / 75 = False
División:  100 / 76 = False
División:  100 / 77 = False
División:  100 / 78 = False
División:  100 / 79 = False
N° Primo:  79
División:  100 / 80 = False
División:  100 / 81 = False
División:  100 / 82 = False
División:  100 / 83 = False
N° Primo:  83
División:  100 / 84 = False
División:  100 / 85 = False
División:  100 / 86 = False
División:  100 / 87 = False
División:  100 / 88 = False
División:  100 / 89 = False
N° Primo:  89
División:  100 / 90 = False
División:  100 / 91 = False
División:  100 / 92 = False
División:  100 / 93 = False
División:  100 / 94 = False
División:  100 / 95 = False
División:  100 / 96 = False
División:  100 / 97 = False
N° Primo:  97
División:  100 / 98 = False

7.Investiga la documentación de la clase string y crea un método que lea una frase del teclado y escriba la primera letra de cada palabra en Mayúscula.

In [38]:
def frase():
    texto = input("Ingrese una frase: ")
    copia = texto.title()
    print(copia)
In [40]:
frase()
Ingrese una frase: me gusta el curso de gomila
Me Gusta El Curso De Gomila

8.Crea una función que calcule el máximo común divisor de dos números introducidos por el usuario por teclado.

In [42]:
def maximo():
    x = input("Ingrese un valor: ")
    y = input("Ingrese otro valor: ")
    return print("Máximo común divisor ",max(x,y))
In [43]:
maximo()
Ingrese un valor: 2
Ingrese otro valor: 5
Máximo común divisor  5

9.Investiga el Cifrado del César y crea una función que lo reproduzca en Python. Cada letra del mensaje original se desplaza tres posiciones en el alfabeto estándar. La A se convierte en la D, la B se convierte en la E, la C se convierte en la F... y cuando se acaba el alfabeto se le vuelve a dar la vuelta: la X se convierte en la A, la Y en la B y la Z en la C. Los números no sufren ninguna modificación.

Formula matemática $f(x) = (x+n) MOD p$ donce:

  • p = es la longitud del alfabeto
  • x = número asociado a la letra 1 = "A" , 2 = "B" ...
  • n = Clave de desplazamiento
In [ ]:
import string
In [44]:
def cifrado_cesar():
    abc = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ"
    frase = str(input("Ingrese la frase a codificar --> "))
    texto = frase.upper()
    ind_abc = 0
    ind_texto = 0
    n = 3 #Clave de desplazamiento
    p = int(len(abc)) #es la longitud del alfabeto
    encriptacion = ""
    
    for t in range(0,len(texto)):
        texto_letra = texto[t]
        pos_t = len(texto) - len(texto) + ind_texto
        ind_texto +=1 
        
        for i in range(0,len(abc)):
            letra = abc[i]
            pos_x = len(abc) - len(abc) + ind_abc #número asociado a la letra
            #Formula matemática
            f = (pos_x + n) % p #f(x) = formula de posición 
            ind_abc+=1    
            
            if (texto_letra == letra):
                encriptacion += abc[f]
                print("Palabra",texto_letra,"posicion:",pos_t,"=",letra,"pos",pos_x,"Encriptado:",abc[f],"pos",f)
    print("PALABRA ENCRIPTADA --> ",encriptacion)                
In [45]:
cifrado_cesar()
Ingrese la frase a codificar --> abcdefghijklmnñopqrstuvwxyz
Palabra A posicion: 0 = A pos 0 Encriptado: D pos 3
Palabra B posicion: 1 = B pos 28 Encriptado: E pos 4
Palabra C posicion: 2 = C pos 56 Encriptado: F pos 5
Palabra D posicion: 3 = D pos 84 Encriptado: G pos 6
Palabra E posicion: 4 = E pos 112 Encriptado: H pos 7
Palabra F posicion: 5 = F pos 140 Encriptado: I pos 8
Palabra G posicion: 6 = G pos 168 Encriptado: J pos 9
Palabra H posicion: 7 = H pos 196 Encriptado: K pos 10
Palabra I posicion: 8 = I pos 224 Encriptado: L pos 11
Palabra J posicion: 9 = J pos 252 Encriptado: M pos 12
Palabra K posicion: 10 = K pos 280 Encriptado: N pos 13
Palabra L posicion: 11 = L pos 308 Encriptado: Ñ pos 14
Palabra M posicion: 12 = M pos 336 Encriptado: O pos 15
Palabra N posicion: 13 = N pos 364 Encriptado: P pos 16
Palabra Ñ posicion: 14 = Ñ pos 392 Encriptado: Q pos 17
Palabra O posicion: 15 = O pos 420 Encriptado: R pos 18
Palabra P posicion: 16 = P pos 448 Encriptado: S pos 19
Palabra Q posicion: 17 = Q pos 476 Encriptado: T pos 20
Palabra R posicion: 18 = R pos 504 Encriptado: U pos 21
Palabra S posicion: 19 = S pos 532 Encriptado: V pos 22
Palabra T posicion: 20 = T pos 560 Encriptado: W pos 23
Palabra U posicion: 21 = U pos 588 Encriptado: X pos 24
Palabra V posicion: 22 = V pos 616 Encriptado: Y pos 25
Palabra W posicion: 23 = W pos 644 Encriptado: Z pos 26
Palabra X posicion: 24 = X pos 672 Encriptado: A pos 0
Palabra Y posicion: 25 = Y pos 700 Encriptado: B pos 1
Palabra Z posicion: 26 = Z pos 728 Encriptado: C pos 2
PALABRA ENCRIPTADA -->  DEFGHIJKLMNÑOPQRSTUVWXYZABC

10.Dado una lista de nombres de persona, escribe un algoritmo que los ordene de tres formas diferentes:

A. De forma alfabética

B. De forma alfabética invertida

C. De nombre más corto al más largo.

In [47]:
def Ordenar():
    print("Ordenamiento")
    lista_nombres = ['juan', 'María', 'Horacio' ,'Ana', 'Xue lee', 'Daniel', 'Patricio', 'Carlos','walter']
    lista_nombres.sort(key = str.lower)
    print("A - Z - Maximo: ",lista_nombres)
    lista_nombres.sort(key=str.lower, reverse=True)
    print("Inverso - Minimo: ",lista_nombres)
    lista_nombres.sort(key = len)
    print("Longitud: ",lista_nombres)
In [48]:
Ordenar()
Ordenamiento
A - Z - Maximo:  ['Ana', 'Carlos', 'Daniel', 'Horacio', 'juan', 'María', 'Patricio', 'walter', 'Xue lee']
Inverso - Minimo:  ['Xue lee', 'walter', 'Patricio', 'María', 'juan', 'Horacio', 'Daniel', 'Carlos', 'Ana']
Longitud:  ['Ana', 'juan', 'María', 'walter', 'Daniel', 'Carlos', 'Xue lee', 'Horacio', 'Patricio']
In [ ]: